home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_350 / memmometer / mminit.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  24KB  |  723 lines
  1. /* : ai=0 bk=0 ts=8 */
  2. #include "mm.h"
  3.  
  4. #define PROJMAX 3               /* number of project menu items */
  5. #define SETUPMAX 2              /* number of setup menu items */
  6. #define MODEMAX 2
  7. #define FREQMAX 4               /* number of frequency menu items */
  8. #define PRIOMAX 16              /* number of priority menu items */
  9. #define CHIPMAX 5               /* number of chip mem size menu items */
  10. #define CHIPAMAX 4              /* number of chip mem base addr menu items */
  11. #define SFMAX 4                 /* number of sf mem size menu items */
  12. #define SFAMAX 4                /* number of sf mem base addr menu items */
  13. #define FASTMAX 7               /* number of fast mem size menu items */
  14. #define FASTAMAX 8              /* number of fast mem base addr menu items */
  15. #define MAXMENU 9               /* total number of top level menus */
  16.  
  17. extern BOOL p_mode;             /* preset frags mode = 0, warps mode = 1 */
  18. extern long p_rate;             /* preset sample interval, secs see menu */
  19. extern long p_priority;         /* preset priority, range -100 to +100   */
  20. extern long p_chip;             /* preset chip mem size, kbytes see menu */
  21. extern long p_chipa;            /* preset chip mem address, kb  see menu */
  22. extern long p_sf;               /* preset slowfast mem size, kb see menu */
  23. extern long p_sfa;              /* preset slowfast mem addr, kb see menu */
  24. extern long p_fast;             /* preset fast mem size, mbytes see menu */
  25. extern long p_fasta;            /* preset fast mem addr, mbytes see menu */
  26.  
  27. /******************************************************/
  28. /*    Structure declarations for the menu sections    */
  29. /******************************************************/
  30.  
  31. struct   MenuItem ProjItem[PROJMAX];
  32. struct   IntuiText ProjText[PROJMAX];
  33. struct   MenuItem SetupItem[SETUPMAX];
  34. struct   IntuiText SetupText[SETUPMAX];
  35. struct   MenuItem ModeItem[MODEMAX];
  36. struct   IntuiText ModeText[MODEMAX];
  37. struct   MenuItem FreqItem[FREQMAX];
  38. struct   IntuiText FreqText[FREQMAX];
  39. struct   MenuItem PrioItem[PRIOMAX];
  40. struct   IntuiText PrioText[PRIOMAX];
  41. struct   MenuItem ChipItem[CHIPMAX];
  42. struct   IntuiText ChipText[CHIPMAX];
  43. struct   MenuItem ChipAItem[CHIPAMAX];
  44. struct   IntuiText ChipAText[CHIPAMAX];
  45. struct   MenuItem SFItem[SFMAX];
  46. struct   IntuiText SFText[SFMAX];
  47. struct   MenuItem SFAItem[SFAMAX];
  48. struct   IntuiText SFAText[SFAMAX];
  49. struct   MenuItem FastItem[FASTMAX];
  50. struct   IntuiText FastText[FASTMAX];
  51. struct   MenuItem FastAItem[FASTAMAX];
  52. struct   IntuiText FastAText[FASTAMAX];
  53. struct   Menu menu[MAXMENU];
  54.  
  55. /*****************************************************************/
  56. /*    The following function initializes the structure arrays    */
  57. /*    needed to provide the Project menu topic.                  */
  58. /*    this was left retro-compatible with Manx 3.4a (nplus1)     */
  59. /*****************************************************************/
  60. void InitProjItems()
  61.     {
  62.     int       n,nplus1;
  63.  
  64. /* initialize each menu item and IntuiText with loop */
  65. for( n=0; n<PROJMAX; n++ )
  66.     {
  67.     nplus1 = n + 1;
  68.     ProjItem[n].NextItem = &ProjItem[nplus1];
  69.     ProjItem[n].LeftEdge = 0;
  70.     ProjItem[n].TopEdge = 9 * n;
  71.     ProjItem[n].Width = 64;
  72.     ProjItem[n].Height = 9;
  73.     ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  74.     ProjItem[n].MutualExclude = 0;
  75.     ProjItem[n].ItemFill = (APTR)&ProjText[n];
  76.     ProjItem[n].SelectFill = NULL;
  77.     ProjItem[n].Command = 0;
  78.     ProjItem[n].SubItem = NULL;
  79.     ProjItem[n].NextSelect = 0;
  80.  
  81.     ProjText[n].FrontPen = BLUP;
  82.     ProjText[n].BackPen = WHTP;
  83.     ProjText[n].DrawMode = JAM2;/* render in fore and background */
  84.     ProjText[n].LeftEdge = 0;
  85.     ProjText[n].TopEdge = 1;
  86.     ProjText[n].ITextFont = NULL;
  87.     ProjText[n].NextText = NULL;
  88.     }
  89. ProjItem[PROJMAX-1].NextItem = NULL;
  90.  
  91. /* initialize text for specific menu items */
  92.  
  93. ProjText[0].IText = (UBYTE *)"Front";
  94. ProjText[1].IText = (UBYTE *)"Back";
  95. ProjText[2].IText = (UBYTE *)"Quit";
  96. }
  97.  
  98. /*****************************************************************/
  99. /*    The following initializes the structure arrays             */
  100. /*   needed to provide the Setup menu topic.                     */
  101. /*****************************************************************/
  102.  
  103. void InitSetupItems()
  104.     {
  105.     int       n,nplus1;
  106.  
  107. /* initialize each menu item and IntuiText with loop */
  108. for( n=0; n<SETUPMAX; n++ )
  109.     {
  110.     nplus1 = n + 1;
  111.     SetupItem[n].NextItem = &SetupItem[nplus1];
  112.     SetupItem[n].LeftEdge = 0;
  113.     SetupItem[n].TopEdge = 9 * n;
  114.     SetupItem[n].Width = 44;
  115.     SetupItem[n].Height = 9;
  116.     SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
  117.     SetupItem[n].MutualExclude = 0;
  118.     SetupItem[n].ItemFill = (APTR)&SetupText[n];
  119.     SetupItem[n].SelectFill = NULL;
  120.     SetupItem[n].Command = 0;
  121.     SetupItem[n].NextSelect = 0;
  122.  
  123.     SetupText[n].FrontPen = BLUP;
  124.     SetupText[n].BackPen = WHTP;
  125.     SetupText[n].DrawMode = JAM2;    
  126.     SetupText[n].LeftEdge = 0;
  127.     SetupText[n].TopEdge = 1;
  128.     SetupText[n].ITextFont = NULL;
  129.     SetupText[n].NextText = NULL;
  130.     }
  131. SetupItem[SETUPMAX-1].NextItem = NULL;
  132.  
  133. SetupText[0].IText = (UBYTE *)"Mode";
  134. SetupItem[0].SubItem = ModeItem;
  135. SetupText[1].IText = (UBYTE *)"Freq";
  136. SetupItem[1].SubItem = FreqItem;
  137.  
  138. /*****************************************************************/
  139. /*    The following initializes the structure arrays             */
  140. /*   needed to provide the Mode submenu topic.                   */
  141. /*****************************************************************/
  142.  
  143. for( n=0; n<MODEMAX; n++ )
  144.     {
  145.     nplus1 = n + 1;
  146.     ModeItem[n].NextItem = &ModeItem[nplus1];
  147.     ModeItem[n].LeftEdge = 38;
  148.     ModeItem[n].TopEdge = 9 * n;
  149.     ModeItem[n].Width = 72;
  150.     ModeItem[n].Height = 9;
  151.     ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  152.     ModeItem[n].MutualExclude = (~(1 << n));
  153.     ModeItem[n].ItemFill = (APTR)&ModeText[n];
  154.     ModeItem[n].SelectFill = NULL;
  155.     ModeItem[n].Command = 0;
  156.     ModeItem[n].SubItem = NULL;
  157.     ModeItem[n].NextSelect = 0;
  158.  
  159.     ModeText[n].FrontPen = BLUP;
  160.     ModeText[n].BackPen = WHTP;
  161.     ModeText[n].DrawMode = JAM2;     /* render in fore and background */
  162.     ModeText[n].LeftEdge = 0;
  163.     ModeText[n].TopEdge = 1;
  164.     ModeText[n].ITextFont = NULL;
  165.     ModeText[n].NextText = NULL;
  166.     }
  167. ModeItem[MODEMAX-1].NextItem = NULL;
  168.  
  169. /* select mode subitem checked */
  170. switch (p_mode) {
  171.     case 0:     n = 0; break;
  172.     case 1:     n = 1; break;
  173.     default:    n = 1; p_mode = FALSE;
  174.     }
  175. ModeItem[n].Flags |= CHECKED;
  176.  
  177. /* initialize text for specific submenu items */
  178. ModeText[0].IText = (UBYTE *)"   Frags";
  179. ModeText[1].IText = (UBYTE *)"   Warps";
  180.  
  181. /*****************************************************************/
  182. /*    The following initializes the structure arrays             */
  183. /*   needed to provide the Freq submenu topic.                   */
  184. /*****************************************************************/
  185.  
  186. for( n=0; n<FREQMAX; n++ )
  187.     {
  188.     nplus1 = n + 1;
  189.     FreqItem[n].NextItem = &FreqItem[nplus1];
  190.     FreqItem[n].LeftEdge = 38;
  191.     FreqItem[n].TopEdge = 9 * n;
  192.     FreqItem[n].Width = 88;
  193.     FreqItem[n].Height = 9;
  194.     FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  195.     FreqItem[n].MutualExclude = (~(1 << n));
  196.     FreqItem[n].ItemFill = (APTR)&FreqText[n];
  197.     FreqItem[n].SelectFill = NULL;
  198.     FreqItem[n].Command = 0;
  199.     FreqItem[n].SubItem = NULL;
  200.     FreqItem[n].NextSelect = 0;
  201.  
  202.     FreqText[n].FrontPen = BLUP;
  203.     FreqText[n].BackPen = WHTP;
  204.     FreqText[n].DrawMode = JAM2;     /* render in fore and background */
  205.     FreqText[n].LeftEdge = 0;
  206.     FreqText[n].TopEdge = 1;
  207.     FreqText[n].ITextFont = NULL;
  208.     FreqText[n].NextText = NULL;
  209.     }
  210. FreqItem[FREQMAX-1].NextItem = NULL;
  211.  
  212. /* select frequency item checked */
  213. switch (p_rate) {
  214.     case 1:     n = 0; break;
  215.     case 2:     n = 1; break;
  216.     case 5:     n = 2; break;
  217.     case 10:    n = 3; break;
  218.     default:    n = 1; p_rate = 2;
  219.     }
  220. FreqItem[n].Flags |= CHECKED;
  221.  
  222. /* initialize text for specific menu items */
  223. FreqText[0].IText = (UBYTE *)"    1 Sec ";
  224. FreqText[1].IText = (UBYTE *)"    2 Secs";
  225. FreqText[2].IText = (UBYTE *)"    5 Secs";
  226. FreqText[3].IText = (UBYTE *)"   10 Secs";
  227. }
  228.  
  229. /*****************************************************************/
  230. /*    The following initializes the structure arrays             */
  231. /*   needed to provide the Priority menu topic.                  */
  232. /*****************************************************************/
  233.  
  234. void InitPrioItems()
  235.     {
  236.     int       n,nplus1;
  237.  
  238. /* initialize each menu item and IntuiText with loop */
  239. for( n=0; n<PRIOMAX; n++ )
  240.     {
  241.     nplus1 = n + 1;
  242.     PrioItem[n].NextItem = &PrioItem[nplus1];
  243.     PrioItem[n].LeftEdge = 0;
  244.     PrioItem[n].TopEdge = 9 * n;
  245.     PrioItem[n].Width = 80;
  246.     PrioItem[n].Height = 9;
  247.     PrioItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  248.     PrioItem[n].MutualExclude = (~(1 << n));
  249.     if (n < 3)  PrioItem[n].MutualExclude &= 0x0007;
  250.     if (n < 1)  PrioItem[n].MutualExclude |= 0x0007;
  251.     PrioItem[n].ItemFill = (APTR)&PrioText[n];
  252.     PrioItem[n].SelectFill = NULL;
  253.     PrioItem[n].Command = 0;
  254.     PrioItem[n].NextSelect = 0;
  255.  
  256.     PrioText[n].FrontPen = BLUP;
  257.     PrioText[n].BackPen = WHTP;
  258.     if (n > 11)  {
  259.         PrioText[n].FrontPen = ORNP;
  260.         PrioText[n].BackPen = REDP;
  261.         }
  262.     PrioText[n].DrawMode = JAM2;    
  263.     PrioText[n].LeftEdge = 0;
  264.     PrioText[n].TopEdge = 1;
  265.     PrioText[n].ITextFont = NULL;
  266.     PrioText[n].NextText = NULL;
  267.     }
  268. PrioItem[PRIOMAX-1].NextItem = NULL;
  269.  
  270. /* select priority item checked */
  271. switch (p_priority) {
  272.     case  -99:     n =  3; break;
  273.     case  -75:     n =  4; break;
  274.     case  -50:     n =  5; break;
  275.     case  -25:     n =  6; break;
  276.     case  -20:     n =  7; break;
  277.     case  -15:     n =  8; break;
  278.     case  -10:     n =  9; break;
  279.     case   -5:     n = 10; break;
  280.     case    0:     n = 11; break;
  281.     case    5:     n = 12; break;
  282.     case   10:     n = 13; break;
  283.     case   15:     n = 14; break;
  284.     case   20:     n = 15; break;
  285.     default:       n = 11; p_priority = 0;
  286.     }
  287. PrioItem[n].Flags |= CHECKED;
  288.  
  289. PrioText[ 0].IText = (UBYTE *)"   NORM   ";
  290. PrioText[ 1].IText = (UBYTE *)"   DECR   ";
  291. PrioText[ 2].IText = (UBYTE *)"   INCR   ";
  292. PrioText[ 3].IText = (UBYTE *)"   -99    ";
  293. PrioText[ 4].IText = (UBYTE *)"   -75    ";
  294. PrioText[ 5].IText = (UBYTE *)"   -50    ";
  295. PrioText[ 6].IText = (UBYTE *)"   -25    ";
  296. PrioText[ 7].IText = (UBYTE *)"   -20    ";
  297. PrioText[ 8].IText = (UBYTE *)"   -15    ";
  298. PrioText[ 9].IText = (UBYTE *)"   -10    ";
  299. PrioText[10].IText = (UBYTE *)"   -5     ";
  300. PrioText[11].IText = (UBYTE *)"    0     ";
  301. PrioText[12].IText = (UBYTE *)"    5     ";
  302. PrioText[13].IText = (UBYTE *)"    10    ";
  303. PrioText[14].IText = (UBYTE *)"    15    ";
  304. PrioText[15].IText = (UBYTE *)"    20    ";
  305. }
  306.  
  307. /*****************************************************************/
  308. /*    The following initializes the structure arrays             */
  309. /*   needed to provide the Chip Mem Size menu topic.             */
  310. /*****************************************************************/
  311.  
  312. void InitChipItems()
  313.     {
  314.     int       n,nplus1;
  315.  
  316. /* initialize each menu item and IntuiText with loop */
  317. for( n=0; n<CHIPMAX; n++ )
  318.     {
  319.     nplus1 = n + 1;
  320.     ChipItem[n].NextItem = &ChipItem[nplus1];
  321.     ChipItem[n].LeftEdge = 0;
  322.     ChipItem[n].TopEdge = 9 * n;
  323.     ChipItem[n].Width = 80;
  324.     ChipItem[n].Height = 9;
  325.     ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  326.     ChipItem[n].MutualExclude = (~(1 << n));
  327.     ChipItem[n].ItemFill = (APTR)&ChipText[n];
  328.     ChipItem[n].SelectFill = NULL;
  329.     ChipItem[n].Command = 0;
  330.     ChipItem[n].NextSelect = 0;
  331.  
  332.     ChipText[n].FrontPen = BLUP;
  333.     ChipText[n].BackPen = WHTP;
  334.     ChipText[n].DrawMode = JAM2;    
  335.     ChipText[n].LeftEdge = 0;
  336.     ChipText[n].TopEdge = 1;
  337.     ChipText[n].ITextFont = NULL;
  338.     ChipText[n].NextText = NULL;
  339.     }
  340. ChipItem[CHIPMAX-1].NextItem = NULL;
  341.  
  342. /* select chip mem size item checked */
  343. switch (p_chip) {
  344.     case    0:     n = 0; break;
  345.     case  256:     n = 1; break;
  346.     case  512:     n = 2; break;
  347.     case 1024:     n = 3; break;
  348.     case 2048:     n = 4; break;
  349.     default:       n = 2; p_chip = 512;
  350.     }
  351. ChipItem[n].Flags |= CHECKED;
  352.  
  353. ChipText[0].IText = (UBYTE *)"   NONE";
  354. ChipText[1].IText = (UBYTE *)"   256K";
  355. ChipText[2].IText = (UBYTE *)"   512K";
  356. ChipText[3].IText = (UBYTE *)"   1 MB";
  357. ChipText[4].IText = (UBYTE *)"   2 MB";
  358. }
  359.  
  360. /*****************************************************************/
  361. /*    The following initializes the structure arrays             */
  362. /*   needed to provide the Chip Base Addr menu topic.            */
  363. /*****************************************************************/
  364.  
  365. void InitChipAItems()
  366.     {
  367.     int       n,nplus1;
  368.  
  369. /* initialize each menu item and IntuiText with loop */
  370. for( n=0; n<CHIPAMAX; n++ )
  371.     {
  372.     nplus1 = n + 1;
  373.     ChipAItem[n].NextItem = &ChipAItem[nplus1];
  374.     ChipAItem[n].LeftEdge = 0;
  375.     ChipAItem[n].TopEdge = 9 * n;
  376.     ChipAItem[n].Width = 80;
  377.     ChipAItem[n].Height = 9;
  378.     ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  379.     ChipAItem[n].MutualExclude = (~(1 << n));
  380.     ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
  381.     ChipAItem[n].SelectFill = NULL;
  382.     ChipAItem[n].Command = 0;
  383.     ChipAItem[n].NextSelect = 0;
  384.  
  385.     ChipAText[n].FrontPen = BLUP;
  386.     ChipAText[n].BackPen = WHTP;
  387.     ChipAText[n].DrawMode = JAM2;    
  388.     ChipAText[n].LeftEdge = 0;
  389.     ChipAText[n].TopEdge = 1;
  390.     ChipAText[n].ITextFont = NULL;
  391.     ChipAText[n].NextText = NULL;
  392.     }
  393. ChipAItem[CHIPAMAX-1].NextItem = NULL;
  394.  
  395. /* select chip base address item checked */
  396. switch (p_chipa) {
  397.     case    0:     n = 0; break;
  398.     case  256:     n = 1; break;
  399.     case  512:     n = 2; break;
  400.     case 1024:     n = 3; break;
  401.     default:       n = 0; p_chipa = 0;
  402.     }
  403. ChipAItem[n].Flags |= CHECKED;
  404.  
  405. ChipAText[0].IText = (UBYTE *)"   @   0K";
  406. ChipAText[1].IText = (UBYTE *)"   @ 256K";
  407. ChipAText[2].IText = (UBYTE *)"   @ 512K";
  408. ChipAText[3].IText = (UBYTE *)"   @ 1 MB";
  409. }
  410.  
  411. /*****************************************************************/
  412. /*    The following initializes the structure arrays             */
  413. /*   needed to provide the Slow Fast Mem Size menu topic.        */
  414. /*****************************************************************/
  415.  
  416. void InitSFItems()
  417.     {
  418.     int       n,nplus1;
  419.  
  420. /* initialize each menu item and IntuiText with loop */
  421. for( n=0; n<SFMAX; n++ )
  422.     {
  423.     nplus1 = n + 1;
  424.     SFItem[n].NextItem = &SFItem[nplus1];
  425.     SFItem[n].LeftEdge = 0;
  426.     SFItem[n].TopEdge = 9 * n;
  427.     SFItem[n].Width = 80;
  428.     SFItem[n].Height = 9;
  429.     SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  430.     SFItem[n].MutualExclude = (~(1 << n));
  431.     SFItem[n].ItemFill = (APTR)&SFText[n];
  432.     SFItem[n].SelectFill = NULL;
  433.     SFItem[n].Command = 0;
  434.     SFItem[n].NextSelect = 0;
  435.  
  436.     SFText[n].FrontPen = BLUP;
  437.     SFText[n].BackPen = WHTP;
  438.     SFText[n].DrawMode = JAM2;    
  439.     SFText[n].LeftEdge = 0;
  440.     SFText[n].TopEdge = 1;
  441.     SFText[n].ITextFont = NULL;
  442.     SFText[n].NextText = NULL;
  443.     }
  444. SFItem[SFMAX-1].NextItem = NULL;
  445.  
  446. /* select slow fast mem size item checked */
  447. switch (p_sf) {
  448.     case    0:     n = 0; break;
  449.     case  512:     n = 1; break;
  450.     case 1024:     n = 2; break;
  451.     case 1536:     n = 3; break;
  452.     default:       n = 0; p_sf = 0;
  453.     }
  454. SFItem[n].Flags |= CHECKED;
  455.  
  456. SFText[0].IText = (UBYTE *)"   NONE  ";
  457. SFText[1].IText = (UBYTE *)"   0.5 MB";
  458. SFText[2].IText = (UBYTE *)"   1   MB";
  459. SFText[3].IText = (UBYTE *)"   1.5 MB";
  460. }
  461.  
  462. /*****************************************************************/
  463. /*    The following initializes the structure arrays             */
  464. /*   needed to provide the Slow Fast Mem Base Addr menu topic.   */
  465. /*****************************************************************/
  466.  
  467. void InitSFAItems()
  468.     {
  469.     int       n,nplus1;
  470.  
  471. /* initialize each menu item and IntuiText with loop */
  472. for( n=0; n<SFAMAX; n++ )
  473.     {
  474.     nplus1 = n + 1;
  475.     SFAItem[n].NextItem = &SFAItem[nplus1];
  476.     SFAItem[n].LeftEdge = 0;
  477.     SFAItem[n].TopEdge = 9 * n;
  478.     SFAItem[n].Width = 104;
  479.     SFAItem[n].Height = 9;
  480.     SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  481.     SFAItem[n].MutualExclude = (~(1 << n));
  482.     SFAItem[n].ItemFill = (APTR)&SFAText[n];
  483.     SFAItem[n].SelectFill = NULL;
  484.     SFAItem[n].Command = 0;
  485.     SFAItem[n].NextSelect = 0;
  486.  
  487.     SFAText[n].FrontPen = BLUP;
  488.     SFAText[n].BackPen = WHTP;
  489.     SFAText[n].DrawMode = JAM2;    
  490.     SFAText[n].LeftEdge = 0;
  491.     SFAText[n].TopEdge = 1;
  492.     SFAText[n].ITextFont = NULL;
  493.     SFAText[n].NextText = NULL;
  494.     }
  495. SFAItem[SFAMAX-1].NextItem = NULL;
  496.  
  497. /* select slow fast mem base address item checked */
  498. switch (p_sfa) {
  499.     case 12288:     n = 0; break;               /* 0x3000 kb = 12   mb */
  500.     case 12800:     n = 1; break;               /* 0x3200 kb = 12.5 mb */
  501.     case 13312:     n = 2; break;               /* 0x3400 kb = 13   mb */
  502.     case 13824:     n = 3; break;               /* 0x3600 kb = 13.5 mb */
  503.     default:        n = 0; p_sfa = 12288;
  504.     }
  505. SFAItem[n].Flags |= CHECKED;
  506.  
  507. SFAText[0].IText = (UBYTE *)"   @ C.0 Meg";
  508. SFAText[1].IText = (UBYTE *)"   @ C.8 Meg";
  509. SFAText[2].IText = (UBYTE *)"   @ D.0 Meg";
  510. SFAText[3].IText = (UBYTE *)"   @ D.8 Meg";
  511. }
  512.  
  513. /*****************************************************************/
  514. /*    The following initializes the structure arrays             */
  515. /*   needed to provide the Fast Mem Size menu topic.             */
  516. /*****************************************************************/
  517.  
  518. void InitFastItems()
  519.     {
  520.     int       n,nplus1;
  521.  
  522. /* initialize each menu item and IntuiText with loop */
  523. for( n=0; n<FASTMAX; n++ )
  524.     {
  525.     nplus1 = n + 1;
  526.     FastItem[n].NextItem = &FastItem[nplus1];
  527.     FastItem[n].LeftEdge = 0;
  528.     FastItem[n].TopEdge = 9 * n;
  529.     FastItem[n].Width = 80;
  530.     FastItem[n].Height = 9;
  531.     FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  532.     FastItem[n].MutualExclude = (~(1 << n));
  533.     FastItem[n].ItemFill = (APTR)&FastText[n];
  534.     FastItem[n].SelectFill = NULL;
  535.     FastItem[n].Command = 0;
  536.     FastItem[n].NextSelect = 0;
  537.  
  538.     FastText[n].FrontPen = BLUP;
  539.     FastText[n].BackPen = WHTP;
  540.     FastText[n].DrawMode = JAM2;    
  541.     FastText[n].LeftEdge = 0;
  542.     FastText[n].TopEdge = 1;
  543.     FastText[n].ITextFont = NULL;
  544.     FastText[n].NextText = NULL;
  545.     }
  546. FastItem[FASTMAX-1].NextItem = NULL;
  547.  
  548. /* select fast mem size item checked */
  549. switch (p_fast) {
  550.     case 0:       n = 0; break;
  551.     case 512:     n = 1; break;
  552.     case 1:       n = 2; break;
  553.     case 2:       n = 3; break;
  554.     case 4:       n = 4; break;
  555.     case 6:       n = 5; break;
  556.     case 8:       n = 6; break;
  557.     default:      n = 0; p_fast = 0;
  558.     }
  559. FastItem[n].Flags |= CHECKED;
  560.  
  561. FastText[0].IText = (UBYTE *)"   NONE";
  562. FastText[1].IText = (UBYTE *)"   512K";
  563. FastText[2].IText = (UBYTE *)"   1 MB";
  564. FastText[3].IText = (UBYTE *)"   2 MB";
  565. FastText[4].IText = (UBYTE *)"   4 MB";
  566. FastText[5].IText = (UBYTE *)"   6 MB";
  567. FastText[6].IText = (UBYTE *)"   8 MB";
  568. }
  569.  
  570. /*****************************************************************/
  571. /*    The following initializes the structure arrays             */
  572. /*   needed to provide the Fast Mem Base Addr menu topic.        */
  573. /*****************************************************************/
  574.  
  575. void InitFastAItems()
  576.     {
  577.     int       n,nplus1;
  578.  
  579. /* initialize each menu item and IntuiText with loop */
  580. for( n=0; n<FASTAMAX; n++ )
  581.     {
  582.     nplus1 = n + 1;
  583.     FastAItem[n].NextItem = &FastAItem[nplus1];
  584.     FastAItem[n].LeftEdge = 0;
  585.     FastAItem[n].TopEdge = 9 * n;
  586.     FastAItem[n].Width = 80;
  587.     FastAItem[n].Height = 9;
  588.     FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  589.     FastAItem[n].MutualExclude = (~(1 << n));
  590.     FastAItem[n].ItemFill = (APTR)&FastAText[n];
  591.     FastAItem[n].SelectFill = NULL;
  592.     FastAItem[n].Command = 0;
  593.     FastAItem[n].NextSelect = 0;
  594.  
  595.     FastAText[n].FrontPen = BLUP;
  596.     FastAText[n].BackPen = WHTP;
  597.     FastAText[n].DrawMode = JAM2;    
  598.     FastAText[n].LeftEdge = 0;
  599.     FastAText[n].TopEdge = 1;
  600.     FastAText[n].ITextFont = NULL;
  601.     FastAText[n].NextText = NULL;
  602.     }
  603. FastAItem[FASTAMAX-1].NextItem = NULL;
  604.  
  605. /* select fast base address item checked */
  606. switch (p_fasta) {
  607.     case 2:     n = 0; break;
  608.     case 3:     n = 1; break;
  609.     case 4:     n = 2; break;
  610.     case 5:     n = 3; break;
  611.     case 6:     n = 4; break;
  612.     case 7:     n = 5; break;
  613.     case 8:     n = 6; break;
  614.     case 9:     n = 7; break;
  615.     default:    n = 0; p_fasta = 2;
  616.     }
  617. FastAItem[n].Flags |= CHECKED;
  618.  
  619. FastAText[0].IText = (UBYTE *)"   @ 2 M";
  620. FastAText[1].IText = (UBYTE *)"   @ 3 M";
  621. FastAText[2].IText = (UBYTE *)"   @ 4 M";
  622. FastAText[3].IText = (UBYTE *)"   @ 5 M";
  623. FastAText[4].IText = (UBYTE *)"   @ 6 M";
  624. FastAText[5].IText = (UBYTE *)"   @ 7 M";
  625. FastAText[6].IText = (UBYTE *)"   @ 8 M";
  626. FastAText[7].IText = (UBYTE *)"   @ 9 M";
  627. }
  628.  
  629. /****************************************************************/
  630. /*   The following function inits the Menu structure array with */
  631. /*  appropriate values for our simple menu.  Review the manual  */
  632. /*  if you need to know what each value means.                  */
  633. /****************************************************************/
  634. void InitMenu()
  635. {
  636. menu[0].NextMenu = &menu[1];
  637. menu[0].LeftEdge = 0;
  638. menu[0].TopEdge = 0;
  639. menu[0].Width = 64;
  640. menu[0].Height = 10;
  641. menu[0].Flags = MENUENABLED;
  642. menu[0].MenuName = "Project";        /* text for menu-bar display */
  643. menu[0].FirstItem = &ProjItem[0];    /* pointer to first item in list */
  644.  
  645. menu[1].NextMenu = &menu[2];
  646. menu[1].LeftEdge = 64;
  647. menu[1].TopEdge = 0;
  648. menu[1].Width = 48;
  649. menu[1].Height = 10;
  650. menu[1].Flags = MENUENABLED;
  651. menu[1].MenuName = "Setup";          /* text for menu-bar display */
  652. menu[1].FirstItem = &SetupItem[0];   /* pointer to first item in list */
  653.  
  654. menu[2].NextMenu = &menu[3];
  655. menu[2].LeftEdge = 112;
  656. menu[2].TopEdge = 0;
  657. menu[2].Width = 72;
  658. menu[2].Height = 10;
  659. menu[2].Flags = MENUENABLED;
  660. menu[2].MenuName = "Priority";       /* text for menu-bar display */
  661. menu[2].FirstItem = &PrioItem[0];    /* pointer to first item in list */
  662.  
  663. menu[3].NextMenu = &menu[4];
  664. menu[3].LeftEdge = 184;
  665. menu[3].TopEdge = 0;
  666. menu[3].Width = 80;
  667. menu[3].Height = 10;
  668. menu[3].Flags = MENUENABLED;
  669. menu[3].MenuName = "Chip Size";      /* text for menu-bar display */
  670. menu[3].FirstItem = &ChipItem[0];    /* pointer to first item in list */
  671.  
  672. menu[4].NextMenu = &menu[5];
  673. menu[4].LeftEdge = 264;
  674. menu[4].TopEdge = 0;
  675. menu[4].Width = 80;
  676. menu[4].Height = 10;
  677. menu[4].Flags = MENUENABLED;
  678. menu[4].MenuName = "Chip Addr";      /* text for menu-bar display */
  679. menu[4].FirstItem = &ChipAItem[0];   /* pointer to first item in list */
  680.  
  681. menu[5].NextMenu = &menu[6];
  682. menu[5].LeftEdge = 344;
  683. menu[5].TopEdge = 0;
  684. menu[5].Width = 64;
  685. menu[5].Height = 10;
  686. menu[5].Flags = MENUENABLED;
  687. menu[5].MenuName = "SF Size";        /* text for menu-bar display */
  688. menu[5].FirstItem = &SFItem[0];      /* pointer to first item in list */
  689.  
  690. menu[6].NextMenu = &menu[7];
  691. menu[6].LeftEdge = 408;
  692. menu[6].TopEdge = 0;
  693. menu[6].Width = 64;
  694. menu[6].Height = 10;
  695. menu[6].Flags = MENUENABLED;
  696. menu[6].MenuName = "SF Addr";        /* text for menu-bar display */
  697. menu[6].FirstItem = &SFAItem[0];     /* pointer to first item in list */
  698.  
  699. menu[7].NextMenu = &menu[8];
  700. menu[7].LeftEdge = 472;
  701. menu[7].TopEdge = 0;
  702. menu[7].Width = 80;
  703. menu[7].Height = 10;
  704. menu[7].Flags = MENUENABLED;
  705. menu[7].MenuName = "Fast Size";      /* text for menu-bar display */
  706. menu[7].FirstItem = &FastItem[0];    /* pointer to first item in list */
  707.  
  708. menu[8].NextMenu = NULL;
  709. menu[8].LeftEdge = 552;
  710. menu[8].TopEdge = 0;
  711. menu[8].Width = 80;
  712. menu[8].Height = 10;
  713. menu[8].Flags = MENUENABLED;
  714. menu[8].MenuName = "Fast Addr";      /* text for menu-bar display */
  715. menu[8].FirstItem = &FastAItem[0];   /* pointer to first item in list */
  716.  
  717. }
  718.  
  719. void StartMenus()
  720. {
  721. SetMenuStrip(window,&menu[0]);
  722. }
  723.